#!/usr/bin/env node

import {Command} from 'commander';
import {ServerManager} from './core/ServerManager';
import {Logger} from './utils/Logger';
import {ConfigLoader} from './utils/ConfigLoader';
import {ServerConfig} from './types';
import {version} from '../package.json';
import fs from 'fs';
import path from 'path';

// 导出主要类和版本，便于模块引用
export {ServerManager} from './core/ServerManager';
export {Logger} from './utils/Logger';
export {ConfigLoader} from './utils/ConfigLoader';
export {version};

// 解析代理配置
function parseProxyConfig(value: string): Record<string, string> {
  if (!value) return {};

  return value.split(',').reduce((config, item) => {
    // 找到第一个冒号的位置
    const firstColonIndex = item.indexOf(':');
    if (firstColonIndex > 0) {
      const path = item.substring(0, firstColonIndex);
      const target = item.substring(firstColonIndex + 1);
      if (path && target) {
        config[path] = target;
      }
    }
    return config;
  }, {} as Record<string, string>);
}

// 将启动服务器的逻辑封装到函数中，便于测试
export function startServer(isTest = false) {
  const program = new Command();
  const logger = Logger.getInstance();

  // 定义命令行参数
  program
    .name('ngt')
    .description('一个轻量级静态文件服务器')
    .version(version)
    .option('-p, --port <port>', '服务器端口号')
    .option('-d, --dir <path>', '要服务的目录路径')
    .option('-c, --compress', '启用gzip压缩')
    .option('--cors', '启用CORS支持')
    .option('--cache <seconds>', '设置缓存过期时间（秒）')
    .option('--proxy <urls>', '设置代理转发规则，格式如 "/api:http://localhost:3000"', parseProxyConfig)
    .option('--open', '启动服务器后自动打开浏览器')
    .option('-q, --quiet', '静默模式，减少日志输出')
    .option('--config <path>', '指定配置文件路径')
    .action(() => {
      // 默认操作，直接启动服务器
      const options = program.opts();
      startServerWithOptions(options, isTest);
    });

  // 生成配置文件命令
  program
    .command('init')
    .description('生成配置文件')
    .option('-p, --path <path>', '配置文件路径', './ngate.config.js')
    .option('--json', '生成JSON格式的配置文件', false)
    .action((options) => {
      const configPath = options.path;
      const isJson = options.json || configPath.endsWith('.json');
      const config = ConfigLoader.getDefaultConfig();

      let configContent;
      if (isJson) {
        configContent = JSON.stringify(config, null, 2);
      } else {
        configContent = `module.exports = ${JSON.stringify(config, null, 2)
          .replace(/"(\w+)":/g, '$1:') // 将"key"转换为key
          .replace(/"/g, '\'') // 将双引号替换为单引号
        };`;
      }

      try {
        const dir = path.dirname(configPath);
        if (!fs.existsSync(dir)) {
          fs.mkdirSync(dir, {recursive: true});
        }

        fs.writeFileSync(configPath, configContent);
        logger.info(`配置文件已生成: ${path.resolve(configPath)}`);
      } catch (error) {
        logger.error(`生成配置文件失败: ${error instanceof Error ? error.message : String(error)}`);
        process.exit(1);
      }
    });

  program.parse(process.argv);

  // 使用参数启动服务器
  function startServerWithOptions(options: any, isTest: boolean): void {
    // 加载配置，优先级：命令行参数 > 指定的配置文件 > 自动发现的配置文件 > 默认配置
    const fileConfig = options.config
      // 从指定的配置文件加载
      ? ConfigLoader.loadConfigFromPath(options.config)
      // 自动搜索配置文件
      : ConfigLoader.autoLoadConfig();

    // 创建一个只包含用户明确提供的选项的对象
    const cliConfig: Partial<ServerConfig> = {};

    // 快速配置映射
    const configMap: Record<string, (val: any) => void> = {
      port: val => cliConfig.port = parseInt(val, 10),
      dir: val => cliConfig.directory = val,
      compress: val => cliConfig.compress = val,
      cors: val => cliConfig.cors = val,
      cache: val => cliConfig.cacheMaxAge = parseInt(val, 10),
      proxy: val => cliConfig.proxyRules = val,
      open: val => cliConfig.openBrowser = val
    };
    // 处理命令行参数
    Object.keys(options).forEach(key => {
      const handler = configMap[key];
      if (handler && options[key] !== undefined) {
        handler(options[key]);
      }
    });
    // 合并配置
    const config = ConfigLoader.mergeConfigs(fileConfig, cliConfig);

    // 设置日志级别
    if (options.quiet) {
      Logger.setLogLevel('error');
    } else if (config.logging.level) {
      Logger.setLogLevel(config.logging.level);
    }

    // 启动服务器
    const serverManager = new ServerManager(config);

    // 在测试模式下不实际启动服务器
    if (!isTest) {
      serverManager.start();
    }

    // 处理进程退出
    process.on('SIGINT', () => {
      logger.info('接收到终止信号，正在关闭服务器...');
      serverManager.stop();
      process.exit(0);
    });

    process.on('uncaughtException', (err) => {
      logger.error(`未捕获的异常: ${err.message}`);
      serverManager.stop();
      process.exit(1);
    });
  }
}

// 当直接通过命令行运行时才执行以下代码
if (require.main === module) {
  startServer();
}
